package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade TIPO_INSTRUMENTO_ENSAIO
 * @author Gerado pelo Telescope
 */
public class EntTipoInstrumentoEnsaio extends Entity {
    
    public final static String ENTITY_NAME = "ZTEST.TIPO_INSTRUMENTO_ENSAIO";
    public final static String TABLE_NAME = "TIPO_INSTRUMENTO_ENSAIO";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntTipoInstrumentoEnsaio() {
        super();
        initialize();
    }
    
    public EntTipoInstrumentoEnsaio(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Tipo do instrumento"); 
        aNome.setRequired(true);
        aNome.setSize(64);
        oNome = new DomUpper();
        aDescricao = new DomTextLong(this,"DESCRICAO", "Descrição do tipo de instrumento"); 
        aDescricao.setSize(512);
        oDescricao = new DomTextLong();
        aExigeCertificadoCalibracao = new DomFlag(this,"EXIGE_CERTIFICADO_CALIBRACAO", "Exige certificado de calibração"); 
        aExigeCertificadoCalibracao.setRequired(true);
        aExigeCertificadoCalibracao.setDefaultValue("N");
        oExigeCertificadoCalibracao = new DomFlag();
        aEComponente = new DomFlag(this,"E_COMPONENTE", "É um componente/dispositivo?"); 
        aEComponente.setRequired(true);
        oEComponente = new DomFlag();
        aOfereceDadosLeitura = new DomFlag(this,"OFERECE_DADOS_LEITURA", "Oferece dados para ensaio"); 
        aOfereceDadosLeitura.setRequired(true);
        aOfereceDadosLeitura.setSize(1);
        aOfereceDadosLeitura.clearOptions();
        aOfereceDadosLeitura.addOption("I", "Intervalo de valores");
        aOfereceDadosLeitura.addOption("N", "Não disponibiliza");
        aOfereceDadosLeitura.setDefaultValue("N");
        oOfereceDadosLeitura = new DomFlag();
        aMascaraValorColetado = new DomText(this,"MASCARA_VALOR_COLETADO", "Máscara do valor coletado"); 
        oMascaraValorColetado = new DomText();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Tipo do instrumento
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Descrição do tipo de instrumento
    private DomTextLong aDescricao;
    private DomTextLong oDescricao;
    
    // Exige certificado de calibração
    private DomFlag aExigeCertificadoCalibracao;
    private DomFlag oExigeCertificadoCalibracao;
    
    // É um componente/dispositivo?
    private DomFlag aEComponente;
    private DomFlag oEComponente;
    
    // Oferece dados para ensaio
    private DomFlag aOfereceDadosLeitura;
    private DomFlag oOfereceDadosLeitura;
    
    // Máscara do valor coletado
    private DomText aMascaraValorColetado;
    private DomText oMascaraValorColetado;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntTipoInstrumentoEnsaio id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntTipoInstrumentoEnsaio nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRICAO">
    
    public EntTipoInstrumentoEnsaio descricao(String value) {
        setDescricao(value);
        return this;
    }
    
    public void setDescricao(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value.getValue());
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(String value) {
        if (value == null) {
            nullifyDescricao();
        } else {
            aDescricao.setValue(value);
            if (aDescricao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescricao(Object value) {
        aDescricao.setValue(value);
        if (aDescricao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescricao() {
        if (!aDescricao.isNull()) {
            aDescricao.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescricao() {
        return aDescricao;
    }
    
    public DomTextLong oldDescricao() {
        return oDescricao;
    }
    
    public String valueOfDescricao() {
        return aDescricao.getValue();
    }
    
    public boolean isDescricaoModified() {
        return aDescricao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo EXIGE_CERTIFICADO_CALIBRACAO">
    
    public EntTipoInstrumentoEnsaio exigeCertificadoCalibracao(String value) {
        setExigeCertificadoCalibracao(value);
        return this;
    }
    
    public void setExigeCertificadoCalibracao(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyExigeCertificadoCalibracao();
        } else {
            aExigeCertificadoCalibracao.setValue(value.getValue());
            if (aExigeCertificadoCalibracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeCertificadoCalibracao(String value) {
        if (value == null) {
            nullifyExigeCertificadoCalibracao();
        } else {
            aExigeCertificadoCalibracao.setValue(value);
            if (aExigeCertificadoCalibracao.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setExigeCertificadoCalibracao(Object value) {
        aExigeCertificadoCalibracao.setValue(value);
        if (aExigeCertificadoCalibracao.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyExigeCertificadoCalibracao() {
        if (!aExigeCertificadoCalibracao.isNull()) {
            aExigeCertificadoCalibracao.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getExigeCertificadoCalibracao() {
        return aExigeCertificadoCalibracao;
    }
    
    public DomFlag oldExigeCertificadoCalibracao() {
        return oExigeCertificadoCalibracao;
    }
    
    public String valueOfExigeCertificadoCalibracao() {
        return aExigeCertificadoCalibracao.getValue();
    }
    
    public boolean isExigeCertificadoCalibracaoModified() {
        return aExigeCertificadoCalibracao.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo E_COMPONENTE">
    
    public EntTipoInstrumentoEnsaio eComponente(String value) {
        setEComponente(value);
        return this;
    }
    
    public void setEComponente(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyEComponente();
        } else {
            aEComponente.setValue(value.getValue());
            if (aEComponente.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEComponente(String value) {
        if (value == null) {
            nullifyEComponente();
        } else {
            aEComponente.setValue(value);
            if (aEComponente.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setEComponente(Object value) {
        aEComponente.setValue(value);
        if (aEComponente.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyEComponente() {
        if (!aEComponente.isNull()) {
            aEComponente.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getEComponente() {
        return aEComponente;
    }
    
    public DomFlag oldEComponente() {
        return oEComponente;
    }
    
    public String valueOfEComponente() {
        return aEComponente.getValue();
    }
    
    public boolean isEComponenteModified() {
        return aEComponente.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo OFERECE_DADOS_LEITURA">
    
    public EntTipoInstrumentoEnsaio ofereceDadosLeitura(String value) {
        setOfereceDadosLeitura(value);
        return this;
    }
    
    public void setOfereceDadosLeitura(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyOfereceDadosLeitura();
        } else {
            aOfereceDadosLeitura.setValue(value.getValue());
            if (aOfereceDadosLeitura.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOfereceDadosLeitura(String value) {
        if (value == null) {
            nullifyOfereceDadosLeitura();
        } else {
            aOfereceDadosLeitura.setValue(value);
            if (aOfereceDadosLeitura.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setOfereceDadosLeitura(Object value) {
        aOfereceDadosLeitura.setValue(value);
        if (aOfereceDadosLeitura.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyOfereceDadosLeitura() {
        if (!aOfereceDadosLeitura.isNull()) {
            aOfereceDadosLeitura.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getOfereceDadosLeitura() {
        return aOfereceDadosLeitura;
    }
    
    public DomFlag oldOfereceDadosLeitura() {
        return oOfereceDadosLeitura;
    }
    
    public String valueOfOfereceDadosLeitura() {
        return aOfereceDadosLeitura.getValue();
    }
    
    public boolean isOfereceDadosLeituraModified() {
        return aOfereceDadosLeitura.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MASCARA_VALOR_COLETADO">
    
    public EntTipoInstrumentoEnsaio mascaraValorColetado(String value) {
        setMascaraValorColetado(value);
        return this;
    }
    
    public void setMascaraValorColetado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyMascaraValorColetado();
        } else {
            aMascaraValorColetado.setValue(value.getValue());
            if (aMascaraValorColetado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMascaraValorColetado(String value) {
        if (value == null) {
            nullifyMascaraValorColetado();
        } else {
            aMascaraValorColetado.setValue(value);
            if (aMascaraValorColetado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMascaraValorColetado(Object value) {
        aMascaraValorColetado.setValue(value);
        if (aMascaraValorColetado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMascaraValorColetado() {
        if (!aMascaraValorColetado.isNull()) {
            aMascaraValorColetado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getMascaraValorColetado() {
        return aMascaraValorColetado;
    }
    
    public DomText oldMascaraValorColetado() {
        return oMascaraValorColetado;
    }
    
    public String valueOfMascaraValorColetado() {
        return aMascaraValorColetado.getValue();
    }
    
    public boolean isMascaraValorColetadoModified() {
        return aMascaraValorColetado.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_TIPO_INSTRUMENTO
        {
            EntInstrumentoEnsaio external = new EntInstrumentoEnsaio(ctx);
            external.findByTipoInstrumentoEnsaio(valueOfId());
            if (external.next()) {
                throw new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_TIPO_INSTRUMENTO.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Instrumentos para ensaios fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_INEN_TIPO_INSTRUMENTO") >= 0) {
                e = new AdsException("ZTEST.INSTRUMENTO_ENSAIO.FK_INEN_TIPO_INSTRUMENTO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Instrumentos para ensaios fazendo referencia para este registro! (FK_INEN_TIPO_INSTRUMENTO)");
                return e;
            } else {
                e = new AdsException("ZTEST.TIPO_INSTRUMENTO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PK_TPIE") >= 0) {
                e = new AdsException("ZTEST.TIPO_INSTRUMENTO_ENSAIO.PK_TPIE", 
                        Severity.ERROR,
                        "ID duplicado! (PK_TPIE)");
                return e;
            } else if (msg.indexOf("UK_DISPMD_NOME") >= 0) {
                e = new AdsException("ZTEST.TIPO_INSTRUMENTO_ENSAIO.UK_DISPMD_NOME", 
                        Severity.ERROR,
                        "Registro duplicado! Nome do dispositivo deve ser único Tipo do instrumento ${NOME} (UK_DISPMD_NOME)");
                return e;
            } else {
                e = new AdsException("ZTEST.TIPO_INSTRUMENTO_ENSAIO.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aDescricao);
            allAttributes.add(aExigeCertificadoCalibracao);
            allAttributes.add(aEComponente);
            allAttributes.add(aOfereceDadosLeitura);
            allAttributes.add(aMascaraValorColetado);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNome(String nome) throws AdsException {
        findBy(new String[] {"NOME"},
                new Object[] {nome});
    }
    /**
     * Retorna os registros de INSTRUMENTO_ENSAIO que referenciam este registro através do atributo TIPO_INSTRUMENTO_ENSAIO_ID
     */
    public EntInstrumentoEnsaio findAllInstrumentoEnsaioTipoInstrumentoEnsaio() throws AdsException {
        return findAllInstrumentoEnsaioTipoInstrumentoEnsaio("order by ID");
    }
    
    /**
     * Retorna os registros de INSTRUMENTO_ENSAIO que referenciam este registro através do atributo TIPO_INSTRUMENTO_ENSAIO_ID
     */
    public EntInstrumentoEnsaio findAllInstrumentoEnsaioTipoInstrumentoEnsaio(String sqlAppend) throws AdsException {
        EntInstrumentoEnsaio out = new EntInstrumentoEnsaio(ctx);
        out.find("select ID from INSTRUMENTO_ENSAIO where TIPO_INSTRUMENTO_ENSAIO_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oOfereceDadosLeitura.setValue(aOfereceDadosLeitura);
        oExigeCertificadoCalibracao.setValue(aExigeCertificadoCalibracao);
        oEComponente.setValue(aEComponente);
        oMascaraValorColetado.setValue(aMascaraValorColetado);
        oId.setValue(aId);
        oNome.setValue(aNome);
        oDescricao.setValue(aDescricao);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntTipoInstrumentoEnsaio.class);
            rule.setName("PK_TPIE");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntTipoInstrumentoEnsaio.class);
            rule.setName("UK_DISPMD_NOME");
            rule.addAttribute(new DomUpper("NOME",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntTipoInstrumentoEnsaio.class);
            rule.setCheckAttribute(new DomFlag("OFERECE_DADOS_LEITURA",""));
            rule.setName("CKAV_20401165");
            rule.addAllowableValues(new String[] {"N", "I"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getOfereceDadosLeitura().isNull()) {
            setOfereceDadosLeitura(getOfereceDadosLeitura().getDefaultValue());
        }
        if (getExigeCertificadoCalibracao().isNull()) {
            setExigeCertificadoCalibracao(getExigeCertificadoCalibracao().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
}
